package com.liy.cloud.common.pw.service.impl;

import com.liy.cloud.common.pw.dao.PwAccountListDao;
import com.liy.cloud.common.pw.dao.PwAccountMainDao;
import com.liy.cloud.common.pw.entity.PwAccountBillEntity;
import com.liy.cloud.common.pw.entity.PwAccountListEntity;
import com.liy.cloud.common.pw.entity.PwAccountMainEntity;
import com.liy.cloud.common.pw.entity.PwSystemStorageEntity;
import com.liy.cloud.common.pw.service.PwAccountBillService;
import com.liy.cloud.common.pw.service.PwAccountListService;
import com.liy.cloud.common.pw.service.PwAccountMainService;
import com.liy.cloud.common.pw.service.PwSystemStorageService;
import com.liy.cloud.common.pw.utils.PwConstant;
import com.das.framework.common.dao.IBaseDao;
import com.das.framework.common.exception.BusinessException;
import com.das.framework.common.service.impl.BaseServiceImpl;
import com.das.framework.common.utils.DateUtil;
import com.das.framework.common.utils.Tools;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.*;

/**
 * @Author: liyang
 * @Date: 2018/6/19 16:18
 **/
@Service
public class PwAccountMainServiceImpl extends BaseServiceImpl<PwAccountMainEntity, String> implements PwAccountMainService {

    protected static Logger log = LoggerFactory.getLogger(PwAccountMainServiceImpl.class);

    @Autowired
    private PwAccountMainDao accountMainDao;

    @Autowired
    PwAccountListDao accountListDao;

    @Autowired
    private PwAccountListService accountListService;

    @Autowired
    private PwAccountBillService accountBillService;

    @Autowired
    private PwSystemStorageService systemStorageService;

    @Override
    public IBaseDao<PwAccountMainEntity, String> getDao() {
        return accountMainDao;
    }

    @Override
    public String generateAccountId(PwAccountMainEntity mainEntity) throws Exception{
        // 查询最新的一条记录
        PwAccountMainEntity latestEntity = getLatestEntity(mainEntity.getSystemId(), mainEntity.getType());
        String accountYear = DateUtil.dateToString(new Date()).substring(0, 4);
        // 默认序号设置为0
        String lsatAccountNum = "0";
        if (latestEntity != null) {
            String lastAId = latestEntity.getAccountId();
            // 获取最新的一条记录的年份 [倒数第10位（包含）~ 倒数第6位（不包含）)
            String year = lastAId.substring(lastAId.length() - 10, lastAId.length() - 6);
            // 如果最新的一条记录的年份等于当前年份，则新增的单据序号在此基础上 +1，否则使用默认值（重新从000001开始）
            if (accountYear.equals(year)) {
                // 取后6位
                lsatAccountNum = lastAId.substring(lastAId.length() - 6, lastAId.length());
            }
        }
        int newAccountInt = Integer.parseInt(lsatAccountNum) + 1;
        String realStringAccountInt = String.valueOf(newAccountInt);
        StringBuffer buffer = new StringBuffer();
        // 如果序号不足6位，则高位用0补齐
        for (int realLen = realStringAccountInt.length(); realLen < 6; realLen++) {
            buffer.append("0");
        }
        return mainEntity.getAccountId().replaceAll("#", "") + accountYear + buffer + realStringAccountInt;
    }

    @Override
    public String getDefaultAccountId(String accountFirst) throws Exception {
        return accountFirst + DateUtil.getTimeNow("yyyy") + "######";
    }

    @Override
    public void addAccountBill(PwAccountMainEntity mainEntity, PwAccountListEntity listEntity, PwSystemStorageEntity storageEntity, String operType, String inOutF) throws Exception {
        // 流水bill
        PwAccountBillEntity billEntity = new PwAccountBillEntity();
        // 1.ID
        billEntity.setId(Tools.getNewUUID());
        // 2.车站编号
        billEntity.setSystemId(mainEntity.getSystemId());
        // 3.单据编号
        billEntity.setAccountId(mainEntity.getAccountId());
        // 4.单据类型 (查数据字典)
        billEntity.setType(mainEntity.getType());
        // 5.物品Id
        billEntity.setItemId(storageEntity.getItemId());
        // 6.物品状态
        billEntity.setStatus(listEntity.getItemStatus());
        // 7.有效期
        billEntity.setVaildTime(storageEntity.getValidTime());
        // 8.操作类型 (查数据字典)  作废 0;  审核 2
        billEntity.setOperType(operType);
        // 9.出入库标识
        billEntity.setInoutF(inOutF);
        // 10.操作数量
        if (listEntity.getActNum() != null) {
            billEntity.setOperNum(listEntity.getActNum());
        }
        // 11.剩余数量 == 库存实际数量
        if (storageEntity.getCurrentNum() != null) {
            billEntity.setNumLeft(storageEntity.getCurrentNum());
        }
        // 12.操作金额
        if (listEntity.getActMoney() != null) {
            billEntity.setOperMoney(listEntity.getActMoney());
        }
        // 13.剩余金额 = 库存实际金额
        if (storageEntity.getCurrentMoney() != null) {
            billEntity.setMoneyLeft(storageEntity.getCurrentMoney());
        }
        switch (operType){
            case PwConstant.BILL_OPER_TYPE_CHECK:
                // 14.审核员 == Main主表的审核人
                billEntity.setCheckOper(mainEntity.getCheckOper());
                // 15.审核时间 == Main主表的审核时间
                billEntity.setCheckDate(mainEntity.getCheckDate());
                break;
            case PwConstant.BILL_OPER_TYPE_INVALID:
                // 14.审核员 == Main主表的作废
                billEntity.setCheckOper(mainEntity.getInvalidOper());
                // 15.审核时间 == Main主表的作废时间
                billEntity.setCheckDate(mainEntity.getInvalidDate());
                break;
            default:
                // 14.审核员 == Main主表的操作人
                billEntity.setCheckOper(mainEntity.getOper());
                // 15.审核时间 == Main主表的操作时间
                billEntity.setCheckDate(mainEntity.getOperDate());
        }
        accountBillService.add(billEntity);
    }

    @Override
    public PwSystemStorageEntity addPwSystemStorageEntity(PwAccountListEntity listEntity) throws Exception {
        PwSystemStorageEntity storageEntity;
        storageEntity = new PwSystemStorageEntity();
        // 库存编号
        storageEntity.setId(Tools.getNewUUID());
        // 车站编号
        storageEntity.setSystemId(listEntity.getSystemId());
        // 物品编号
        storageEntity.setItemId(listEntity.getItemId());
        // 物品类型
        storageEntity.setType(listEntity.getItemType());
        // 有效期
        storageEntity.setValidTime(listEntity.getValidTime());
        // 物品状态
        storageEntity.setStatus(listEntity.getItemStatus());
        // 设置当前金额
        storageEntity.setCurrentMoney(listEntity.getActMoney());
        // 设置当前数量
        storageEntity.setCurrentNum(listEntity.getActNum());
        // 新增前检测库存金额
        if (storageEntity.getCurrentMoney() !=null && storageEntity.getCurrentMoney() < 0) {
            throw new BusinessException("第" + listEntity.getSeq() + "行：新增库存失败，库存金额不能小于0！");
        }
        // 新增前检测库存数量
        if (storageEntity.getCurrentNum() !=null && storageEntity.getCurrentNum() < 0) {
            throw new BusinessException("第" + listEntity.getSeq() + "行：新增库存失败，库存数量不能小于0！");
        }
        // 新增库存
        systemStorageService.add(storageEntity);
        return storageEntity;
    }

    @Override
    public void takeOutPwSystemStorage(PwAccountMainEntity mainEntity, List<PwAccountListEntity> list) throws Exception {
        // 单据编号
        mainEntity.setAccountId(generateAccountId(mainEntity));
        // 1.新增 主表Mian
        accountMainDao.insertSelective(mainEntity);

        // 库存缓存列表，多次更新同一条库存时先缓存上一次更新过的记录
        List<PwSystemStorageEntity> cacheList = new ArrayList<>();
        // 明细List 流水Bill 和 库存Storage
        for (PwAccountListEntity listEntity : list) {
            // 设置明细表主键
            listEntity.setId(Tools.getNewUUID());
            // 主单据编号
            listEntity.setAccountId(mainEntity.getAccountId());
            // 单据类型
            listEntity.setType(mainEntity.getType());
            // 2.新增 明细List
            accountListService.add(listEntity);

            // 更新的库存，先查询库存总量，计算实际库存
            PwSystemStorageEntity storageEntity = null;
            // 先从缓存列表中查询
            for (PwSystemStorageEntity entity: cacheList) {
                if(entity.getSystemId().equals(listEntity.getSystemId()) && entity.getItemId().equals(listEntity.getItemId())){
                    storageEntity = entity;
                    break;
                }
            }
            // 如果缓存列表中不存在，从数据库中查询
            if(storageEntity == null){
                storageEntity = systemStorageService.queryStorageBySystemIdAndItemId(listEntity.getSystemId(), listEntity.getItemId());
                // 如果数据库中也没有则抛出异常
                if (storageEntity == null) {
                    throw new BusinessException("第" + listEntity.getSeq() + "行：该物品库存中不存在！");
                }
                // 更新的库存加入缓存列表
                cacheList.add(storageEntity);
            }
            // 设置当前金额
            if (listEntity.getActMoney() != null && listEntity.getActMoney() != 0 && storageEntity.getCurrentMoney() != null) {
                storageEntity.setCurrentMoney(storageEntity.getCurrentMoney() - listEntity.getActMoney());
            }
            // 设置当前数量
            if (listEntity.getActNum() != null && listEntity.getActNum() != 0 && storageEntity.getCurrentNum() != null) {
                storageEntity.setCurrentNum(storageEntity.getCurrentNum() - listEntity.getActNum());
            }
            // 更新前检测库存金额
            if (storageEntity.getCurrentMoney() !=null && storageEntity.getCurrentMoney() < 0) {
                throw new BusinessException("第" + listEntity.getSeq() + "行：库存金额不足！");
            }
            // 更新前检测库存数量
            if (storageEntity.getCurrentNum() !=null && storageEntity.getCurrentNum() < 0) {
                throw new BusinessException("第" + listEntity.getSeq() + "行：库存数量不足！");
            }
            // 3.库存storage变动
            systemStorageService.updateBySystemIdAndItemId(storageEntity);

            // 流水bill，操作类型：审核，出入库标识：出库
            addAccountBill(mainEntity, listEntity, storageEntity, PwConstant.BILL_OPER_TYPE_CHECK, PwConstant.BILL_INOUT_TYPE_OUT);
        }
    }

    @Override
    public void putInPwSystemStorage(PwAccountMainEntity mainEntity, List<PwAccountListEntity> list) throws Exception {
        // 单据编号
        mainEntity.setAccountId(generateAccountId(mainEntity));
        // 新增 主表Mian
        accountMainDao.insertSelective(mainEntity);

        // 库存缓存列表，多次更新同一条库存时先缓存上一次更新过的记录
        List<PwSystemStorageEntity> cacheList = new LinkedList<>();
        // 明细List 流水Bill 和 库存Storage
        for (PwAccountListEntity listEntity : list) {
            // 设置明细表主键
            listEntity.setId(Tools.getNewUUID());
            // 主单据编号
            listEntity.setAccountId(mainEntity.getAccountId());
            // 单据类型
            listEntity.setType(mainEntity.getType());
            // 新增 明细List
            accountListService.add(listEntity);

            // 更新/添加的库存，先查询库存总量，计算实际库存。
            PwSystemStorageEntity storageEntity = null;
            // 先从缓存列表中查询
            for (PwSystemStorageEntity entity: cacheList) {
                if(entity.getSystemId().equals(listEntity.getSystemId()) && entity.getItemId().equals(listEntity.getItemId())){
                    storageEntity = entity;
                    break;
                }
            }
            // 如果缓存列表中不存在，从数据库中查询
            if(storageEntity == null){
                storageEntity = systemStorageService.queryStorageBySystemIdAndItemId(listEntity.getSystemId(), listEntity.getItemId());
                if(storageEntity != null){
                    // 更新的库存加入缓存列表
                    cacheList.add(storageEntity);
                }
            }
            // 库存中没有则新增
            if(storageEntity == null){
                // 新增库存
                storageEntity = addPwSystemStorageEntity(listEntity);
                // 添加的库存加入缓存列表
                cacheList.add(storageEntity);
            }else { // 库存中已经存在则更新
                // 设置当前金额
                if (listEntity.getActMoney() != null && listEntity.getActMoney() != 0 && storageEntity.getCurrentMoney() != null) {
                    storageEntity.setCurrentMoney(storageEntity.getCurrentMoney() + listEntity.getActMoney());
                }
                // 设置当前数量
                if (listEntity.getActNum() != null && listEntity.getActNum() != 0 && storageEntity.getCurrentNum() != null) {
                    storageEntity.setCurrentNum(storageEntity.getCurrentNum() + listEntity.getActNum());
                }
                // 更新前检测库存金额
                if (storageEntity.getCurrentMoney() !=null && storageEntity.getCurrentMoney() < 0) {
                    throw new BusinessException("第" + listEntity.getSeq() + "行：更新库存失败，库存金额不能小于0！");
                }
                // 更新前检测库存数量
                if (storageEntity.getCurrentNum() !=null && storageEntity.getCurrentNum() < 0) {
                    throw new BusinessException("第" + listEntity.getSeq() + "行：更新库存失败，库存数量不能小于0！");
                }
                // 更新库存
                systemStorageService.updateBySystemIdAndItemId(storageEntity);
            }

            // 流水bill，操作类型：审核，出入库标识：入库
            addAccountBill(mainEntity, listEntity, storageEntity, PwConstant.BILL_OPER_TYPE_CHECK, PwConstant.BILL_INOUT_TYPE_IN);
        }
    }

    @Override
    public void invalidOutSystemStorage(String accountId) throws Exception {
        // 查询要作废的单据
        PwAccountMainEntity mainEntity = accountMainDao.selectByAccountId(accountId);
        if(mainEntity == null){
            throw new BusinessException("查询不到编号为：“" + accountId + "” 的单据！");
        }
        // 单据作废
        mainEntity.invalid();
        // 更新单据
        accountMainDao.updateMainEntityBtAccountId(mainEntity);
        // 查询明细，回滚库存（出库操作）
        rollBackOutSystemStorage(mainEntity);
    }

    @Override
    public void rollBackOutSystemStorage(PwAccountMainEntity mainEntity) throws Exception {
        // 查询明细，回滚库存（出库操作）
        List<PwAccountListEntity> list = accountListDao.getListByAccountId(mainEntity.getAccountId());
        // 库存缓存列表，多次更新同一条库存时先缓存上一次更新过的记录
        List<PwSystemStorageEntity> cacheList = new ArrayList<>();
        for(PwAccountListEntity listEntity : list){
            // 更新的库存，先查询库存总量，计算实际库存
            PwSystemStorageEntity storageEntity = null;
            // 先从缓存列表中查询
            for (PwSystemStorageEntity entity: cacheList) {
                if(entity.getSystemId().equals(listEntity.getSystemId()) && entity.getItemId().equals(listEntity.getItemId())){
                    storageEntity = entity;
                    break;
                }
            }
            // 如果缓存列表中不存在，从数据库中查询
            if(storageEntity == null){
                storageEntity = systemStorageService.queryStorageBySystemIdAndItemId(listEntity.getSystemId(), listEntity.getItemId());
                // 如果数据库中也没有则跳过
                if (storageEntity == null) {
                    throw new BusinessException("找不到编号为：“" + listEntity.getItemId() + "” 的物品库存！");
                }
                // 更新的库存加入缓存列表
                cacheList.add(storageEntity);
            }
            // 设置当前金额
            if (listEntity.getActMoney() != null && listEntity.getActMoney() != 0 && storageEntity.getCurrentMoney() != null) {
                storageEntity.setCurrentMoney(storageEntity.getCurrentMoney() - listEntity.getActMoney());
            }
            // 设置当前数量
            if (listEntity.getActNum() != null && listEntity.getActNum() != 0 && storageEntity.getCurrentNum() != null) {
                storageEntity.setCurrentNum(storageEntity.getCurrentNum() - listEntity.getActNum());
            }
            // 更新前检测库存金额
            if (storageEntity.getCurrentMoney() !=null && storageEntity.getCurrentMoney() < 0) {
                throw new BusinessException("编号为：“" + listEntity.getItemId() + "” 的库存金额不能小于0！");
            }
            // 更新前检测库存数量
            if (storageEntity.getCurrentNum() !=null && storageEntity.getCurrentNum() < 0) {
                throw new BusinessException("编号为：“" + listEntity.getItemId() + "” 的库存数量不能小于0！");
            }
            // 更新库存
            systemStorageService.updateBySystemIdAndItemId(storageEntity);
            // 流水记录 操作类型：作废 出入库标识：出库
            addAccountBill(mainEntity,listEntity, storageEntity, PwConstant.BILL_OPER_TYPE_INVALID, PwConstant.BILL_INOUT_TYPE_OUT);
        }
    }

    @Override
    public void invalidInSystemStorage(String accountId) throws Exception {
        // 查询要作废的单据
        PwAccountMainEntity mainEntity = accountMainDao.selectByAccountId(accountId);
        if(mainEntity == null){
            throw new BusinessException("查询不到编号为：“" + accountId + "” 的单据！");
        }
        // 单据作废
        mainEntity.invalid();
        // 更新单据
        accountMainDao.updateMainEntityBtAccountId(mainEntity);
        // 查询明细，回滚库存（入库操作）
        rollBackInSystemStorage(mainEntity);
    }

    @Override
    public void rollBackInSystemStorage(PwAccountMainEntity mainEntity) throws Exception {
        // 查询明细，回滚库存（入库操作）
        List<PwAccountListEntity> list = accountListDao.getListByAccountId(mainEntity.getAccountId());
        // 库存缓存列表，多次更新同一条库存时先缓存上一次更新过的记录
        List<PwSystemStorageEntity> cacheList = new ArrayList<>();
        for(PwAccountListEntity listEntity : list){
            // 更新的库存，先查询库存总量，计算实际库存
            PwSystemStorageEntity storageEntity = null;
            // 先从缓存列表中查询
            for (PwSystemStorageEntity entity: cacheList) {
                if(entity.getSystemId().equals(listEntity.getSystemId()) && entity.getItemId().equals(listEntity.getItemId())){
                    storageEntity = entity;
                    break;
                }
            }
            // 如果缓存列表中不存在，从数据库中查询
            if(storageEntity == null){
                storageEntity = systemStorageService.queryStorageBySystemIdAndItemId(listEntity.getSystemId(), listEntity.getItemId());
                // 如果数据库中也没有则抛出异常
                if (storageEntity == null) {
                    throw new BusinessException("找不到编号为：“" + listEntity.getItemId() + "” 的物品库存！");
                }
                // 更新的库存加入缓存列表
                cacheList.add(storageEntity);
            }
            // 设置当前金额
            if (listEntity.getActMoney() != null && listEntity.getActMoney() != 0 && storageEntity.getCurrentMoney() != null) {
                storageEntity.setCurrentMoney(storageEntity.getCurrentMoney() + listEntity.getActMoney());
            }
            // 设置当前数量
            if (listEntity.getActNum() != null && listEntity.getActNum() != 0 && storageEntity.getCurrentNum() != null) {
                storageEntity.setCurrentNum(storageEntity.getCurrentNum() + listEntity.getActNum());
            }
            // 更新前检测库存金额
            if (storageEntity.getCurrentMoney() !=null && storageEntity.getCurrentMoney() < 0) {
                throw new BusinessException("编号为：“" + listEntity.getItemId() + "” 的库存金额不能小于0！");
            }
            // 更新前检测库存数量
            if (storageEntity.getCurrentNum() !=null && storageEntity.getCurrentNum() < 0) {
                throw new BusinessException("编号为：“" + listEntity.getItemId() + "” 的库存数量不能小于0！");
            }
            // 更新库存
            systemStorageService.updateBySystemIdAndItemId(storageEntity);
            // 流水记录 操作类型：作废 出入库标识：入库
            addAccountBill(mainEntity,listEntity, storageEntity, PwConstant.BILL_OPER_TYPE_INVALID, PwConstant.BILL_INOUT_TYPE_IN);
        }
    }

    /*
     * @Author:  liyang
     * @Date:    2018/6/28  10:00
     * @Description: 获取最新的一条记录(操作时间排序  operDate)
     * @params: systemId: 车站编号  type:单据类型
     **/
    @Override
    public PwAccountMainEntity getLatestEntity(String systemId, String type) {
        PwAccountMainEntity query = new PwAccountMainEntity();
        query.setSystemId(systemId);
        query.setType(type);
        return accountMainDao.getLatestEntity(query);
    }

    /*
     * @Author:  liyang
     * @Date:    2018/6/28  10:00
     * @Description: 获取最新的一条 已经审核的记录 ( 审核时间排序 checkDate )
     * @params: systemId: 车站编号  type:单据类型
     **/
    @Override
    public PwAccountMainEntity getLatestEntityHasChecked(String systemId, String type) {
        PwAccountMainEntity query = new PwAccountMainEntity();
        query.setSystemId(systemId);
        query.setType(type);
        return accountMainDao.getLatestEntityHasChecked(query);
    }

    /**
     * @Author:  zhangw
     * @param accountId 单据编号
     * @Description: 单据编号查询
     */
    public PwAccountMainEntity selectByAccountId(String accountId){
        return accountMainDao.selectByAccountId(accountId);
    }

    /*
     * @Author:  liyang
     * @Date:    2018/7/4  15:06
     * @Description: 新增交接班: 主表单Mian, 明细list, 出入库记录流水Bill, 库存信息Storage
     **/
    @Override
    public void addHandover(PwAccountMainEntity mainEntity, List<PwAccountListEntity> list) throws Exception {

        // 单据编号
        String accountId = generateAccountId(mainEntity);
        mainEntity.setAccountId(accountId);

        // 1.新增 主表Mian
        accountMainDao.insertSelective(mainEntity);
        // 2.新增 明细List
        for (PwAccountListEntity value : list) {
            value.setId(Tools.getNewUUID());
            // 主单据编号
            value.setAccountId(accountId);
            accountListService.add(value);
        }
        // 流水Bill 和 库存Storage
        for (PwAccountListEntity listEntity : list) {
            PwSystemStorageEntity storageEntity = new PwSystemStorageEntity();
            // 车站编号
            storageEntity.setSystemId(listEntity.getSystemId());
            // 物品ID
            storageEntity.setItemId(listEntity.getItemId());
            // 设置当前金额
            if (listEntity.getNumDiff() != null && listEntity.getNumDiff() != 0) {
                storageEntity.setCurrentNum(listEntity.getActNum());
            }
            // 设置当前数量
            if (listEntity.getMoneyDiff() != null && listEntity.getMoneyDiff() != 0) {
                storageEntity.setCurrentMoney(listEntity.getActMoney());
            }
            //3.库存storage变动
            systemStorageService.updateBySystemIdAndItemId(storageEntity);

            //流水bill
            PwAccountBillEntity billEntity = new PwAccountBillEntity();
            // ID
            billEntity.setId(Tools.getNewUUID());
            // 车站编号
            billEntity.setSystemId(mainEntity.getSystemId());
            // Bill 单据编号
            billEntity.setAccountId(accountId);
            // 单据类型 (查数据字典) 车站客值交接班记录: 31
            billEntity.setType("31");
            // 物品Id
            billEntity.setItemId(listEntity.getItemId());
            // 物品状态
            billEntity.setStatus(listEntity.getItemStatus());
            // 有效期
            billEntity.setVaildTime(listEntity.getValidTime());
            //操作类型 (查数据字典)  审核: 2
            billEntity.setOperType(PwConstant.PW_ACCOUNTID_STATUS_CHECK);
            //操作数量
            if (listEntity.getNumDiff() != null && listEntity.getNumDiff() != 0) {
                billEntity.setOperNum(listEntity.getNumDiff());
            }
            //剩余数量 == 实际数量
            billEntity.setNumLeft(listEntity.getActNum());
            //操作金额
            if (listEntity.getMoneyDiff() != null && listEntity.getMoneyDiff() != 0) {
                billEntity.setOperMoney(listEntity.getMoneyDiff());
            }
            //剩余金额 = 实际金额
            billEntity.setMoneyLeft(listEntity.getActMoney());
            //审核员 == Main主表的审核人
            billEntity.setCheckOper(mainEntity.getCheckOper());
            //审核时间
            billEntity.setCheckDate(DateUtil.getTimeNow());
            // 4.出入库流水记录bill
            accountBillService.add(billEntity);
        }

    }


    /*
     * @Author:  liyang
     * @Date:    2018/7/4  15:06
     * @Description: 新增库存调整:
     **/
    @Override
    public void addAdjustStorage(PwAccountMainEntity mainEntity, List<PwAccountListEntity> list) throws Exception {
        //车站编号
        String systemId = mainEntity.getSystemId();
        //审核员 = 操作员
        String oper = mainEntity.getOper();
        //审核时间
        String checkDate = mainEntity.getCheckDate();
        // 单据编号
        String accountId = generateAccountId(mainEntity);
        mainEntity.setAccountId(accountId);

        // 查询出当前车站库存中 所有的物品
        List<PwSystemStorageEntity> PwSystemStorageEntity = systemStorageService.queryStorageDataBySystemId(systemId);
        // 当前库存物品 itemid 集合
        List<String> itemIds = new ArrayList<>();
        for(PwSystemStorageEntity entity : PwSystemStorageEntity){
            itemIds.add( entity.getItemId());
        }

        //1.库存storage变动
        for (PwAccountListEntity listEntity : list) {

            // 明细物品的 itemId
            String listItemId = listEntity.getItemId();

            PwSystemStorageEntity storageEntity = new PwSystemStorageEntity();
            // 车站编号
            storageEntity.setSystemId(systemId);
            // 物品ID
            storageEntity.setItemId(listItemId);
            //有效期
            storageEntity.setValidTime(listEntity.getValidTime());
            // 状态
            storageEntity.setStatus(listEntity.getItemStatus());
            //类型
            storageEntity.setType(listEntity.getItemIdType());

            // 设置当前金额
            if (listEntity.getNumDiff() != null && listEntity.getNumDiff() != 0) {
                storageEntity.setCurrentNum(listEntity.getActNum());
            }
            // 设置当前数量
            if (listEntity.getMoneyDiff() != null && listEntity.getMoneyDiff() != 0) {
                storageEntity.setCurrentMoney(listEntity.getActMoney());
            }

            // 如果物品 已经存在于车站库存中 更新数量即可
            if( itemIds.contains( listItemId) ){
                // 1.更新库存中已存在的物品
                systemStorageService.updateBySystemIdAndItemId(storageEntity);
            }else {
                // 2.添加库存没有的新物品
                storageEntity.setId(Tools.getNewUUID());
                systemStorageService.add(storageEntity);
            }

            //2.出入库流水记录bill
            PwAccountBillEntity billEntity = new PwAccountBillEntity();
            billEntity.setId(Tools.getNewUUID());
            //车站编号
            billEntity.setSystemId(systemId);
            // Bill 单据编号
            billEntity.setAccountId(accountId);
            //单据类型
            billEntity.setType("TZ");
            //物品Id
            billEntity.setItemId(listEntity.getItemId());
            //物品状态
            billEntity.setStatus(listEntity.getItemStatus());
            //有效期
            billEntity.setVaildTime(listEntity.getValidTime());
            //操作类型
            billEntity.setOperType("1");
            //操作数量
            if (listEntity.getNumDiff() != null && listEntity.getNumDiff() != 0) {
                billEntity.setOperNum(listEntity.getNumDiff());
            }
            //剩余数量 == 实际数量
            billEntity.setNumLeft(listEntity.getActNum());
            //操作金额
            if (listEntity.getMoneyDiff() != null && listEntity.getMoneyDiff() != 0) {
                billEntity.setOperMoney(listEntity.getMoneyDiff());
            }
            //剩余金额 = 实际金额
            billEntity.setMoneyLeft(listEntity.getActMoney());
            //审核员 == 当前操作人 == 当前登录用户
            billEntity.setCheckOper(oper);
            //审核时间
            billEntity.setCheckDate(checkDate);

            // 2.出入库流水记录bill
            accountBillService.add(billEntity);
        }
        //3.主表单main,
        accountMainDao.insertSelective(mainEntity);

        //4.明细 list
        for (PwAccountListEntity listEntity : list) {
            // ID
            listEntity.setId(Tools.getNewUUID());
            // 主单据编号
            listEntity.setAccountId(accountId);
            // 车站编号
            listEntity.setSystemId(systemId);
            // 物品类型
            listEntity.setItemType(listEntity.getItemIdType());
            accountListService.add(listEntity);
        }
    }

    /*
     * @Author:  liyang
     * @Date:    2018/7/4  15:06
     * @Description: 新增车站配发车票:
     **/
    @Override
    public void addAllocateTickets(PwAccountMainEntity mainEntity, List<PwAccountListEntity> list) throws BusinessException,Exception {
        //审核员 = 操作员
        String oper = mainEntity.getOper();
        //审核时间
        String checkDate = mainEntity.getCheckDate();
        // 单据编号
        String accountId = generateAccountId(mainEntity);
        mainEntity.setAccountId(accountId);
        //车站编号
        String systemId = mainEntity.getSystemId();

        //1.库存storage变动
        for (PwAccountListEntity listEntity : list) {
            //itemId
            String itemId = listEntity.getItemId();
            // 旧库存
            PwSystemStorageEntity oldStorageEntity = systemStorageService.queryStorageBySystemIdAndItemId(listEntity.getSystemId(), listEntity.getItemId());
            PwSystemStorageEntity storageEntity = new PwSystemStorageEntity();
            // 车站编号
            storageEntity.setSystemId(listEntity.getSystemId());
            // 物品ID
            storageEntity.setItemId(itemId);

            // 设置当前数量 -- 根据实际数量
            if (listEntity.getActNum() != null) {
                Long oldCurrentNum = oldStorageEntity.getCurrentNum();
                storageEntity.setCurrentNum(listEntity.getActNum() + oldCurrentNum);
            }
            // 设置当前金额 -- 根据实际金额
            if (listEntity.getActMoney() != null) {
                Double oldCurrentMoney = oldStorageEntity.getCurrentMoney();
                storageEntity.setCurrentMoney(listEntity.getActMoney() + oldCurrentMoney);
            }

            // 更新库存
            systemStorageService.updateBySystemIdAndItemId(storageEntity);

            //2.出入库流水记录bill
            PwAccountBillEntity billEntity = new PwAccountBillEntity();
            billEntity.setId(Tools.getNewUUID());
            //车站编号
            billEntity.setSystemId(systemId);
            // Bill 单据编号
            billEntity.setAccountId(accountId);
            //单据类型 数据字典(车站配票类型为11)
            billEntity.setType("11");
            //物品Id
            billEntity.setItemId(itemId);
            //物品状态
            billEntity.setStatus(listEntity.getItemStatus());
            //有效期
            billEntity.setVaildTime(listEntity.getValidTime());
            //操作类型
            billEntity.setOperType(PwConstant.PW_ACCOUNTID_STATUS_CHECK);
            //操作数量 == 实际配票数量
            if (listEntity.getActNum() != null) {
                billEntity.setOperNum(listEntity.getActNum());
                //剩余数量 ==  更新后的 库存实际数量
                billEntity.setNumLeft(listEntity.getActNum() + oldStorageEntity.getCurrentNum());
            } else {
                //剩余数量 ==  老的 库存实际数量
                billEntity.setNumLeft(oldStorageEntity.getCurrentNum());
            }
            //操作金额 == 实际配票金额
            if (listEntity.getActMoney() != null) {
                billEntity.setOperMoney(listEntity.getActMoney());
                //剩余金额 = 更新后的实际库存金额
                billEntity.setMoneyLeft(listEntity.getActMoney() + oldStorageEntity.getCurrentMoney());
            } else {
                //剩余金额 = 老的实际库存金额
                billEntity.setMoneyLeft(oldStorageEntity.getCurrentMoney());
            }

            //审核员 == 当前操作人 == 当前登录用户
            billEntity.setCheckOper(oper);
            //审核时间
            billEntity.setCheckDate(checkDate);

            // 2.出入库流水记录bill
            accountBillService.add(billEntity);
        }
        //3.主表单main,
        accountMainDao.insertSelective(mainEntity);

        // 4.修改 中心配发 通知单的状态 ( 处理标识为 03 调出车站已处理)
        PwAccountMainEntity centerAllocateNotices = new PwAccountMainEntity();
        centerAllocateNotices.setAccountId(mainEntity.getRelateId());
        // 处理标识为 03
        centerAllocateNotices.setHandleF("03");
        // 根据 AccountId 更新中心调拨通知单状态
        accountMainDao.updateMainEntityBtAccountId(centerAllocateNotices);

        //5.明细 list
        for (PwAccountListEntity listEntity : list) {
            // ID
            listEntity.setId(Tools.getNewUUID());
            //主单据编号
            listEntity.setAccountId(accountId);
            accountListService.add(listEntity);
        }
    }

    /*
     * @Author:  liyang
     * @Date:    2018/7/4  15:06
     * @Description: 新增车站 调出车票:
     **/
    @Override
    public void addSystemAllocateOut(PwAccountMainEntity mainEntity, List<PwAccountListEntity> list) throws BusinessException, Exception {
        //车站编号
        String systemId = mainEntity.getSystemId();
        //审核员 = 操作员
        String oper = mainEntity.getOper();
        //审核时间
        String checkDate = mainEntity.getCheckDate();
        // 主单据编号
        String accountId = generateAccountId(mainEntity);
        // 设置主单据编号
        mainEntity.setAccountId(accountId);

        //1.库存storage变动
        for (PwAccountListEntity listEntity : list) {
            //itemId
            String itemId = listEntity.getItemId();
            // 旧库存
            PwSystemStorageEntity oldStorageEntity = systemStorageService.queryStorageBySystemIdAndItemId(listEntity.getSystemId(), listEntity.getItemId());
            PwSystemStorageEntity storageEntity = new PwSystemStorageEntity();
            // 车站编号
            storageEntity.setSystemId(listEntity.getSystemId());
            // 物品ID
            storageEntity.setItemId(itemId);

            // 设置当前数量 -- 根据实际数量
            if (listEntity.getActNum() != null) {
                Long oldCurrentNum = oldStorageEntity.getCurrentNum();
                // 计算库存剩下的数量
                Long computeCurrentNum = oldCurrentNum - listEntity.getActNum();
                // 库存不足
                if (computeCurrentNum < 0) {
                    throw new BusinessException("物品编号为 "+itemId + " 的库存不足");
                } else {
                    storageEntity.setCurrentNum(computeCurrentNum);
                }
            }
            // 设置当前金额 -- 根据实际金额
            if (listEntity.getActMoney() != null) {
                Double oldCurrentMoney = oldStorageEntity.getCurrentMoney();
                // 计算库存剩下的金额
                double computeCurrentMoney = oldCurrentMoney - listEntity.getActMoney();
                // 库存不足
                if (computeCurrentMoney < 0) {
                    throw new BusinessException("物品编号为 " + itemId + " 的库存不足");
                } else {
                    storageEntity.setCurrentMoney(computeCurrentMoney);
                }
            }

            // 更新库存
            systemStorageService.updateBySystemIdAndItemId(storageEntity);

            //2.出入库流水记录bill
            PwAccountBillEntity billEntity = new PwAccountBillEntity();
            billEntity.setId(Tools.getNewUUID());
            //车站编号
            billEntity.setSystemId(systemId);
            // Bill 单据编号
            billEntity.setAccountId(accountId);
            //单据类型 数据字典 (车站调出车票 25)
            billEntity.setType("25");
            //物品Id
            billEntity.setItemId(itemId);
            //物品状态
            billEntity.setStatus(listEntity.getItemStatus());
            //有效期
            billEntity.setVaildTime(listEntity.getValidTime());
            //流水账出入库标识  出库 1
            billEntity.setInoutF("1");

            //操作数量 == 实际配票数量
            if (listEntity.getActNum() != null) {
                billEntity.setOperNum(listEntity.getActNum());
                //剩余数量 ==  更新后的 库存实际数量  出库减少
                billEntity.setNumLeft(oldStorageEntity.getCurrentNum() - listEntity.getActNum());
            } else {
                //剩余数量 ==  老的 库存实际数量
                billEntity.setNumLeft(oldStorageEntity.getCurrentNum());
            }

            //操作金额 == 实际配票金额
            if (listEntity.getActMoney() != null) {
                billEntity.setOperMoney(listEntity.getActMoney());
                //剩余金额 = 更新后的实际库存金额   出库减少
                billEntity.setMoneyLeft(oldStorageEntity.getCurrentMoney() - listEntity.getActMoney());
            } else {
                //剩余金额 = 老的实际库存金额
                billEntity.setMoneyLeft(oldStorageEntity.getCurrentMoney());
            }

            //审核员 == 当前操作人 == 当前登录用户
            billEntity.setCheckOper(oper);
            //审核时间
            billEntity.setCheckDate(checkDate);

            // 2.出入库流水记录bill
            accountBillService.add(billEntity);
        }
        // 3.主表单main,
        accountMainDao.insertSelective(mainEntity);

        // 4.修改 中心调拨通知单的状态 ( 处理标识为 03 调出车站已处理)  (调拨标识 02 调出站已经处理)
        PwAccountMainEntity centerTransferNotices = new PwAccountMainEntity();
        centerTransferNotices.setAccountId(mainEntity.getRelateId());
        // 处理标识为 03
        centerTransferNotices.setHandleF("03");
        // 调出 调拨标识 02
        centerTransferNotices.setAllocationF("02");
        // 根据 AccountId 更新中心调拨通知单状态
        accountMainDao.updateMainEntityBtAccountId(centerTransferNotices);

        //5.明细 list
        for (PwAccountListEntity listEntity : list) {
            // ID
            listEntity.setId(Tools.getNewUUID());
            //主单据编号
            listEntity.setAccountId(accountId);
            accountListService.add(listEntity);
        }
    }

    /*
     * @Author:  liyang
     * @Date:    2018/7/4  15:06
     * @Description: 新增车站 调出车票:
     **/
    @Override
    public void addSystemAllocateIn(PwAccountMainEntity mainEntity, List<PwAccountListEntity> list) throws BusinessException, Exception {
        //车站编号
        String systemId = mainEntity.getSystemId();
        //审核员 = 操作员
        String oper = mainEntity.getOper();
        //审核时间
        String checkDate = mainEntity.getCheckDate();
        // 主单据编号
        String accountId = generateAccountId(mainEntity);
        // 设置主单据编号
        mainEntity.setAccountId(accountId);

        //1.库存storage变动
        for (PwAccountListEntity listEntity : list) {
            //itemId
            String itemId = listEntity.getItemId();
            // 旧库存
            PwSystemStorageEntity oldStorageEntity = systemStorageService.queryStorageBySystemIdAndItemId(listEntity.getSystemId(), listEntity.getItemId());
            PwSystemStorageEntity storageEntity = new PwSystemStorageEntity();
            // 车站编号
            storageEntity.setSystemId(listEntity.getSystemId());
            // 物品ID
            storageEntity.setItemId(itemId);

            // 设置当前数量 -- 根据实际数量
            if (listEntity.getActNum() != null) {
                Long oldCurrentNum = oldStorageEntity.getCurrentNum();
                // 计算库存剩下的数量
                Long computeCurrentNum = oldCurrentNum + listEntity.getActNum();
                storageEntity.setCurrentNum(computeCurrentNum);
            }
            // 设置当前金额 -- 根据实际金额
            if (listEntity.getActMoney() != null) {
                Double oldCurrentMoney = oldStorageEntity.getCurrentMoney();
                // 计算库存剩下的金额
                double computeCurrentMoney = oldCurrentMoney + listEntity.getActMoney();
                storageEntity.setCurrentMoney(computeCurrentMoney);
            }

            // 更新库存
            systemStorageService.updateBySystemIdAndItemId(storageEntity);

            //2.出入库流水记录bill
            PwAccountBillEntity billEntity = new PwAccountBillEntity();
            billEntity.setId(Tools.getNewUUID());
            //车站编号
            billEntity.setSystemId(systemId);
            // Bill 单据编号
            billEntity.setAccountId(accountId);
            //单据类型 数据字典 (车站调入车票 1Z)
            billEntity.setType(mainEntity.getType());
            //物品Id
            billEntity.setItemId(itemId);
            //物品状态
            billEntity.setStatus(listEntity.getItemStatus());
            //有效期

            billEntity.setVaildTime(listEntity.getValidTime());
            //流水账出入库标识  入库 2
            billEntity.setInoutF("2");
            //操作数量 == 实际配票数量
            if (listEntity.getActNum() != null) {
                billEntity.setOperNum(listEntity.getActNum());
                //剩余数量 ==  更新后的 库存实际数量  入库增加
                billEntity.setNumLeft(listEntity.getActNum() + oldStorageEntity.getCurrentNum());
            } else {
                //剩余数量 ==  老的 库存实际数量
                billEntity.setNumLeft(oldStorageEntity.getCurrentNum());
            }

            //操作金额 == 实际配票金额
            if (listEntity.getActMoney() != null) {
                billEntity.setOperMoney(listEntity.getActMoney());
                //剩余金额 = 更新后的实际库存金额  入库增加
                billEntity.setMoneyLeft(listEntity.getActMoney() + oldStorageEntity.getCurrentMoney());
            } else {
                //剩余金额 = 老的实际库存金额
                billEntity.setMoneyLeft(oldStorageEntity.getCurrentMoney());
            }

            //审核员 == 当前操作人 == 当前登录用户
            billEntity.setCheckOper(oper);
            //审核时间
            billEntity.setCheckDate(checkDate);

            // 2.出入库流水记录bill
            accountBillService.add(billEntity);
        }
        // 3.主表单main,
        accountMainDao.insertSelective(mainEntity);

        // 4.修改 中心调拨通知单的状态 ( 处理标识为 03 调入车站已处理)  (调拨标识 04 调出站已经处理)
        PwAccountMainEntity centerTransferNotices = new PwAccountMainEntity();
        centerTransferNotices.setAccountId(mainEntity.getRelateId());
        // 处理标识为 03 已处理
        centerTransferNotices.setHandleF("03");
        // 调入 调拨标识 04
        centerTransferNotices.setAllocationF("04");
        // 根据 AccountId 更新中心调拨通知单状态
        accountMainDao.updateMainEntityBtAccountId(centerTransferNotices);

        //5.明细 list
        for (PwAccountListEntity listEntity : list) {
            // ID
            listEntity.setId(Tools.getNewUUID());
            //主单据编号
            listEntity.setAccountId(accountId);
            accountListService.add(listEntity);
        }
    }


    /*
     * @Author:  liyang
     * @Date:    2018/7/12  19:08
     * @Description: 新增-上交车票:
     *
     **/
    @Override
    public void addSystemHandTickets(PwAccountMainEntity mainEntity, List<PwAccountListEntity> list) throws BusinessException, Exception{

        //车站编号
        String systemId = mainEntity.getSystemId();
        //审核员 = 操作员
        String oper = mainEntity.getOper();
        //审核时间
        String checkDate = mainEntity.getCheckDate();
        // 主单据编号
        String accountId = generateAccountId(mainEntity);
        // 设置主单据编号
        mainEntity.setAccountId(accountId);
        //1.库存storage变动 上交车票库存相应 减少
        for (PwAccountListEntity listEntity : list) {
            //itemId
            String itemId = listEntity.getItemId();
            // 旧库存
            PwSystemStorageEntity oldStorageEntity = systemStorageService.queryStorageBySystemIdAndItemId(systemId, listEntity.getItemId());
            // 需要上交的物品 在本车站中不存在;
            if(oldStorageEntity == null  ){
                throw new BusinessException("物品编号为: "+itemId + " 的票卡库存为空,无法上交");
            }
            PwSystemStorageEntity storageEntity = new PwSystemStorageEntity();
            // 车站编号
            storageEntity.setSystemId(listEntity.getSystemId());
            // 物品ID
            storageEntity.setItemId(itemId);

            // 设置当前数量 -- 根据实际数量
            if (listEntity.getActNum() != null) {
                Long oldCurrentNum = oldStorageEntity.getCurrentNum();
                // 计算库存剩下的数量
                Long computeCurrentNum = oldCurrentNum - listEntity.getActNum();
                // 库存不足
                if (computeCurrentNum < 0) {
                    throw new BusinessException("物品编号为: "+itemId + " 的票卡库存不足,无法上交");
                } else {
                    storageEntity.setCurrentNum(computeCurrentNum);
                }
            }

            // 更新库存
            systemStorageService.updateBySystemIdAndItemId(storageEntity);

            //2.出入库流水记录bill
            PwAccountBillEntity billEntity = new PwAccountBillEntity();
            billEntity.setId(Tools.getNewUUID());
            //车站编号
            billEntity.setSystemId(systemId);
            // Bill 单据编号
            billEntity.setAccountId(accountId);
            //单据类型 数据字典 (车站上交车票 21)
            billEntity.setType("21");
            //物品Id
            billEntity.setItemId(itemId);
            //物品状态
            billEntity.setStatus(listEntity.getItemStatus());
            //有效期
            billEntity.setVaildTime(listEntity.getValidTime());
            //流水账出入库标识  出库 1
            billEntity.setInoutF("1");

            //操作数量 == 实际配票数量
            if (listEntity.getActNum() != null) {
                billEntity.setOperNum(listEntity.getActNum());
                //剩余数量 ==  更新后的库存 == 老库存 - 实际上交数
                billEntity.setNumLeft(oldStorageEntity.getCurrentNum() - listEntity.getActNum());
            } else {
                //剩余数量 ==  老的库存数量
                billEntity.setNumLeft(oldStorageEntity.getCurrentNum());
            }

            //审核员 == 当前操作人 == 当前登录用户
            billEntity.setCheckOper(oper);
            //审核时间
            billEntity.setCheckDate(checkDate);

            // 2.出入库流水记录bill
            accountBillService.add(billEntity);
        }
        // 3.主表单main,
        accountMainDao.insertSelective(mainEntity);

        // 上交车票组 才有中心上交通知单
        if(mainEntity.getExt1().equals("0")){
            // 4.修改 中心上交通知单的状态 ( 处理标识为 03 车站已处理)
            PwAccountMainEntity centerTransferNotices = new PwAccountMainEntity();
            centerTransferNotices.setAccountId(mainEntity.getRelateId());
            // 处理标识为 03 车站已处理
            centerTransferNotices.setHandleF("03");
            // 根据 AccountId 更新中心调拨通知单状态
            accountMainDao.updateMainEntityBtAccountId(centerTransferNotices);
        }



        //5.明细 list
        for (PwAccountListEntity listEntity : list) {
            //systemId
            listEntity.setSystemId(mainEntity.getSystemId());
            // ID
            listEntity.setId(Tools.getNewUUID());
            //主单据编号
            listEntity.setAccountId(accountId);
            accountListService.add(listEntity);
        }
    }

    /*
     * @Author:  liyang
     * @Date:    2018/7/16  19:08
     * @Description: 新增-申请零钞:
     *
     **/
    @Override
    public void addApplySmallMoney(PwAccountMainEntity mainEntity, List<PwAccountListEntity> list) throws Exception {
        //车站编号
        String systemId = mainEntity.getSystemId();
        // 主单据编号
        String accountId = generateAccountId(mainEntity);
        // 设置主单据编号
        mainEntity.setAccountId(accountId);
        // 3.主表单main,
        accountMainDao.insertSelective(mainEntity);
        //5.明细 list
        for (PwAccountListEntity listEntity : list) {
            //systemId 车站编号
            listEntity.setSystemId(systemId);
            // ID
            listEntity.setId(Tools.getNewUUID());
            // AccountId 主单据编号
            listEntity.setAccountId(accountId);
            accountListService.add(listEntity);
        }
    }

    /*
     * @Author:  liyang
     * @Date:    2018/7/18  17:08
     * @Description: 新增-银行配备用金:
     *
     **/
    @Override
    public void addBankAllocateBackupMoney(PwAccountMainEntity mainEntity,Double backupMoney) throws Exception {

        //车站编号
        String systemId = mainEntity.getSystemId();
        //单据类型:
        String accountType = mainEntity.getType();
        // 主单据编号
        String accountId = generateAccountId(mainEntity);
        // 物品ID ( 这里是备用金) M01
        String itemId = "M01";

        // 1.主表单main,
        mainEntity.setAccountId(accountId);

        // 提交主表单main,
        accountMainDao.insertSelective(mainEntity);

        //  2.明细 list
        PwAccountListEntity listEntity = new PwAccountListEntity();
        //ID
        listEntity.setId(Tools.getNewUUID());
        // 车站编号
        listEntity.setSystemId(systemId);
        //单据类型
        listEntity.setType(accountType);
        // 主单据编号
        listEntity.setAccountId(accountId);
        // 物品ID ( 这里是备用金) M01
        listEntity.setItemId( itemId );
        // 物品状态  1 有效
        listEntity.setItemStatus("1");
        // 配发金额
        listEntity.setActMoney(backupMoney);
        accountListService.add(listEntity);

        //3.库存storage变动 车站无备用金库存 则需要新增一条记录  车站有备用金库存 则更新库存
        PwSystemStorageEntity M01StorageEntity = systemStorageService.queryStorageBySystemIdAndItemId(systemId, itemId);
        PwSystemStorageEntity newStorageEntity = new PwSystemStorageEntity();
        newStorageEntity.setSystemId(systemId);
        newStorageEntity.setItemId(itemId);
        if( M01StorageEntity == null ){
            //新增一条记录
            newStorageEntity.setCurrentMoney(backupMoney);
            newStorageEntity.setId(Tools.getNewUUID());
            systemStorageService.add(newStorageEntity);
        }else {
            //备用金库存更新
            Double oldMoney = M01StorageEntity.getCurrentMoney();
            newStorageEntity.setCurrentMoney(oldMoney + backupMoney);
            systemStorageService.updateBySystemIdAndItemId(newStorageEntity);
        }

        //4.出入库流水记录bill
        addAccountBill(mainEntity,listEntity,newStorageEntity,PwConstant.BILL_OPER_TYPE_CHECK,PwConstant.BILL_INOUT_TYPE_IN);

    }

    /*
     * @Author:  libs
     * @Date:    2018/8/7  16:50
     * @Description: 查询某一天的单据信息，必传字段：审核时间checkDate
     * @params: mainEntity
     **/
    @Override
    public List<PwAccountMainEntity> getOneDay(PwAccountMainEntity mainEntity){
        return accountMainDao.selectOneDay(mainEntity);
    }

    @Override
    public List<Map<String, Object>> getAccountNum() throws Exception {
        return accountMainDao.getAccountNum();
    }
}
